// Package comsdk 提供服务组件脚手架的核心SDK，集成了服务器、通信、注册和安全验证等功能
package comsdk

import (
	"context"
	"net/http"
	"time"

	"gitee.com/yuwenlwl/comsdk/communication"
	"gitee.com/yuwenlwl/comsdk/config"
	"gitee.com/yuwenlwl/comsdk/registry"
	"gitee.com/yuwenlwl/comsdk/security"
	"gitee.com/yuwenlwl/comsdk/server"
)

// -----------------------------
// 从 config 包导出的函数和类型
// -----------------------------

// ServiceConfig 保存服务组件配置
type ServiceConfig = config.ServiceConfig

// LoadConfig 加载服务组件配置(从环境变量或.env文件)
func LoadConfig() ServiceConfig {
	return config.LoadFromEnv()
}

// -----------------------------
// 从 communication 包导出的函数
// -----------------------------

// SetSharedSecret 设置组件间通信的共享密钥
func SetSharedSecret(secret string) {
	communication.SetSharedSecret(secret)
}

// SetTimeout 设置HTTP请求超时时间
func SetTimeout(timeout time.Duration) {
	communication.SetTimeout(timeout)
}

// NewRequest 创建新的组件间通信请求
func NewRequest(target, path, method string, payload interface{}) *communication.Request {
	return communication.NewRequest(target, path, method, payload)
}

// VerifyRequest 验证组件间通信请求
func VerifyRequest(r *http.Request) ([]byte, error) {
	return communication.VerifyRequest(r)
}

// HandleComponentRequest 处理组件间通信请求的HTTP处理器
func HandleComponentRequest(handler func(payload []byte) (*communication.Response, error)) http.HandlerFunc {
	return communication.HandleComponentRequest(handler)
}

// Response 组件间通信响应
type Response = communication.Response

// -----------------------------
// 从 security 包导出的函数和类型
// -----------------------------

// SecurityConfig 保存安全配置
type SecurityConfig = security.SecurityConfig

// Verifier 安全验证接口
type Verifier = security.Verifier

// NewVerifier 创建新的安全验证器
func NewVerifier(appID, appSecret string) Verifier {
	return security.NewVerifier(appID, appSecret)
}

// NewVerifierWithConfig 使用配置创建验证器
func NewVerifierWithConfig(config *SecurityConfig) Verifier {
	return security.NewVerifierWithConfig(config)
}

// -----------------------------
// 从 server 包导出的函数和类型
// -----------------------------

// HealthStatus 健康状态
type HealthStatus = server.HealthStatus

// CheckResult 检查结果
type CheckResult = server.CheckResult

// HealthCheck 健康检查函数类型
type HealthCheck = server.HealthCheck

// HealthManager 健康检查管理器
type HealthManager = server.HealthManager

// Server 核心服务器
type Server = server.Server

// NewServer 创建新的服务器实例
func NewServer(version string, verifier Verifier) *Server {
	return server.NewServer(version, verifier)
}

// JSONResponse 发送JSON响应
func JSONResponse(w http.ResponseWriter, status int, data interface{}) {
	server.JSONResponse(w, status, data)
}

// ErrorResponse 发送错误响应
func ErrorResponse(w http.ResponseWriter, status int, message string) {
	server.ErrorResponse(w, status, message)
}

// -----------------------------
// 从 registry 包导出的函数和类型
// -----------------------------

// ComponentInfo 组件信息
type ComponentInfo = registry.ComponentInfo

// RegisteredComponent 已注册组件的详细信息
type RegisteredComponent = registry.RegisteredComponent

// RegistrationStatus 注册状态
type RegistrationStatus = registry.RegistrationStatus

// Registrar 注册器接口
type Registrar = registry.Registrar

// NewRegistrar 创建注册器实例
func NewRegistrar(info ComponentInfo, gatewayURL, registerPath string, verifier Verifier) Registrar {
	return registry.NewRegistrar(info, gatewayURL, registerPath, verifier)
}

// -----------------------------
// 服务组件初始化辅助函数
// -----------------------------

// AppContext 应用上下文，用于存储服务组件的所有核心组件
type AppContext struct {
	Config     ServiceConfig
	Server     *Server
	Verifier   Verifier
	Registrar  Registrar
	Components map[string]interface{}
}

// InitApp 初始化服务组件应用
// 会从环境变量或.env文件中加载配置
// 会自动设置安全验证器、服务器和组件注册器
func InitApp(gatewayURL, registerPath string) (*AppContext, error) {
	// 加载配置
	cfg := LoadConfig()
	if err := cfg.Validate(); err != nil {
		return nil, err
	}

	// 创建应用上下文
	app := &AppContext{
		Config:     cfg,
		Components: make(map[string]interface{}),
	}

	// 创建安全验证器
	app.Verifier = NewVerifier(cfg.AppID, cfg.AppSecret)

	// 创建服务器
	app.Server = NewServer(cfg.Version, app.Verifier)

	// 创建健康检查
	app.Server.HealthManager.RegisterCheck("self", func() (bool, string) {
		return true, "服务组件运行正常"
	})

	// 创建注册器
	info := ComponentInfo{
		AppID:          cfg.AppID,
		Name:           cfg.Name,
		Version:        cfg.Version,
		ServiceURL:     "http://localhost:" + cfg.Port,
		HealthCheckURL: "http://localhost:" + cfg.Port + "/health",
	}
	app.Registrar = NewRegistrar(info, gatewayURL, registerPath, app.Verifier)

	return app, nil
}

// StartApp 启动应用
// 会启动服务器、注册组件和心跳服务
func (app *AppContext) StartApp(ctx context.Context) error {
	// 注册组件
	if err := app.Registrar.Register(); err != nil {
		return err
	}

	// 启动心跳服务
	app.Registrar.StartHeartbeat(ctx, 30*time.Second)

	// 启动服务器（阻塞调用）
	return app.Server.Start(app.Config.Port)
}

// StopApp 停止应用
// 会注销组件并停止服务器
func (app *AppContext) StopApp(ctx context.Context) error {
	// 注销组件
	if err := app.Registrar.Deregister(); err != nil {
		// 只记录错误，不中断关闭流程
	}

	// 停止服务器
	return app.Server.Stop(ctx)
}
